Optimal partial clique edge covering guided by potential energy minimization

For given integers\ua0k,\ua0n,\ua0r\ua0we aim at families of\ua0k\ua0sub-cliques called blocks, of a clique with\ua0n\ua0vertices, such that every block has\ua0r\ua0vertices, and the blocks together cover a maximum number of edges. We demonstrate a combinatorial optimization method that generates such optimal partial clique edge coverings. It takes certain packages of columns (corresponding to vertices) in the incidence matrix of the blocks, considers the number of uncovered edges as an energy term that has to be minimized by transforming these packages. As a proof of concept we can completely solve the above maximization problem in the case of\ua0k≤4k≤4\ua0blocks and obtain optimal coverings for all integers\ua0n\ua0and\ua0r\ua0with\ua0r/n≥5/9r/n≥5/9. This generalizes known results for total coverings to partial coverings. The method as such is not restricted to\ua0k≤4k≤4\ua0blocks, but a challenge for further research (also on total coverings) is to limit the case distinctions when more blocks are involved

Distance-Based Solution of Patrolling Problems with Individual Waiting Times

In patrolling problems, robots (or other vehicles) must perpetually visit certain points without exceeding given individual waiting times. Some obvious applications are monitoring, maintenance, and periodic fetching of resources. We propose a new generic formulation of the problem. As its main advantage, it enables a reduction of the multi-robot case to the one-robot case in a certain graph/hypergraph pair, which also relates the problem to some classic path problems in graphs: NP-hardness is shown by a reduction from the Hamiltonian cycle problem, and on the positive side, the formulation allows solution heuristics using distances in the mentioned graph. We demonstrate this approach for the case of two robots patrolling on a line, a problem whose complexity status is open, apart from approximation results. Specifically, we solve all instances with up to 6 equidistant points, and we find some surprising effects, e.g., critical problem instances (which are feasible instances that become infeasible when any waiting time is diminished) may contain rather large individual waiting times

Enumerating grid layouts of graphs

We study algorithms that generate layouts of graphs with n vertices in a square grid with ν points, where adjacent vertices in the graph are also close in the grid. The problem is motivated by graph drawing and factory layout planning. In the latter application, vertices represent machines, and edges join machines that should be placed next to each other. Graphs admitting a grid layout where all edges have unit length are known as partial grid graphs. Their recognition is NP-hard already in very restricted cases. However, the moderate number of machines in practical instances suggests the use of exact algorithms that may even enumerate the possible layouts to choose from. We start with an elementary nO(√n)\ua0time algorithm, but then we argue that even simpler exponential branching algorithms are more usable for practical sizes n, although being asymptotically worse. One algorithm interpolates between obvious O∗(3n) time and O∗(4ν) time for graphs with many small connected components. It can be modified in order to accommodate also a limited number of edges that can exceed unit length. Next we show that connected graphs have at most 2.9241n\ua0grid layouts that can also be efficiently enumerated. An O∗(2.6458n) time branching algorithm solves the recognition problem, or yields a succinct enumeration of layouts with some surcharge on the time bound. In terms of the grid size we get a slightly better O∗(2.6208ν) time bound. Moreover, if we can identify a subgraph that is rigid, i.e., admits only one layout up to congruence, then all possible layouts of the entire graph are extensions of this unique layout, such that the combinatorial explosion is then confined to the rest of the graph. Therefore we also propose heuristic methods for finding certain types of large rigid subgraphs. The formulations of these results is more technical, however, the proposed method iteratively generates certain rigid subgraphs from smaller ones

Dividing splittable goods evenly and with limited fragmentation

A splittable good provided in n pieces shall be divided as evenly as possible among m agents, where every agent can take shares from at most F pieces. We call F the fragmentation and mainly restrict attention to the cases F= 1 and F= 2. For F= 1 , the max–min and min–max problems are solvable in linear time. The case F= 2 has neat formulations and structural characterizations in terms of weighted graphs. First we focus on perfectly balanced solutions. While the problem is strongly NP-hard in general, it can be solved in linear time if m≥ n- 1 , and a solution always exists in this case, in contrast to F= 1. Moreover, the problem is fixed-parameter tractable in the parameter 2 m- n. (Note that this parameter measures the number of agents above the trivial threshold m= n/ 2.) The structural results suggest another related problem where unsplittable items shall be assigned to subsets so as to balance the average sizes (rather than the total sizes) in these subsets. We give an approximation-preserving reduction from our original splitting problem with fragmentation F= 2 to this averaging problem, and some approximation results in cases when m is close to either n or n\ua0/\ua02

The parallel solution of domination problems on chordal and strongly chordal graphs

AbstractWe present efficient parallel algorithms for the domination problem on strongly chordal graphs and related problems, such as the set cover problem for α-acyclic hypergraphs and the dominating clique problem for strongly chordal graphs. Moreover, we present an efficient parallel algorithm which checks, for any chordal graph, whether it has a dominating clique

Parameterized mixed graph coloring

Coloring of mixed graphs that contain both directed arcs and undirected edges is relevant for scheduling of unit-length jobs with precedence constraints andconflicts. The classic GHRV theorem (attributed to Gallai, Hasse, Roy, and Vitaver) relates graph coloring to longest paths. It can be extended to mixed graphs. In the present paper we further extend the GHRV theorem to weighted mixed graphs. As a byproduct this yields a kernel and a parameterized algorithm (with the number of undirected edges as parameter) that is slightly faster than the brute-force algorithm. The parameter is natural since the directed version is polynomial whereas the undirected version is NP-complete. Furthermore we point out a new polynomial case where the edges form a clique

The solution space of sorting with recurring comparison faults

Suppose that n elements shall be sorted by comparisons, but an unknown subset of at most k pairs systematically returns false comparison results. Using a known connection with feedback arc sets in tournaments (FAST), we characterize the solution space of sorting with recurring comparison faults by a FAST enumeration, which represents all information about the order that can be obtained by doing all comparisons. An optimal parameterized enumeration algorithm for FAST also works for the more general chordal graphs, and this fact contributes to the efficiency of our representation. Then, we compute the solution space more efficiently, by fault-tolerant versions of Treesort and Quicksort. For rare faults the complexity is close to optimal. We propose propose directions of further research, revolving around decision diagrams for sorting with recurring faults

Longest Increasing Subsequence under Persistent Comparison Errors

We study the problem of computing a longest increasing subsequence in a sequence $S$ of $n$ distinct elements in the presence of persistent comparison errors. In this model, every comparison between two elements can return the wrong result with some fixed (small) probability $p$, and comparisons cannot be repeated. Computing the longest increasing subsequence exactly is impossible in this model, therefore, the objective is to identify a subsequence that (i) is indeed increasing and (ii) has a length that approximates the length of the longest increasing subsequence. We present asymptotically tight upper and lower bounds on both the approximation factor and the running time. In particular, we present an algorithm that computes an $O(\log n)$-approximation in time $O(n\log n)$, with high probability. This approximation relies on the fact that that we can approximately sort $n$ elements in $O(n\log n)$ time such that the maximum dislocation of an element is at most $O(\log n)$. For the lower bounds, we prove that (i) there is a set of sequences, such that on a sequence picked randomly from this set every algorithm must return an $\Omega(\log n)$-approximation with high probability, and (ii) any $O(\log n)$-approximation algorithm for longest increasing subsequence requires $\Omega(n \log n)$ comparisons, even in the absence of errors

Optimal group testing algorithms with interval queries and their application to splice site detection

We consider the following constrained version of the classical Group Testing problem: Given a finite set of items identified with the set of natural numbers from 1 to n, and an unknown distinguished subset P of up to ppositive elements, the goal is to identify the items in P by asking the least number of queries of the type "does the subset Q intersect P?", where Q is a subset of consecutive elements of cardinality at most d. This particular case of the Group Testing problem naturally arises in computational biology in the context ofsearching for splice sites within a gene. In this paper we focus on algorithms that solve the aforesaid problem and for which queries can be arranged in stages: in each stage a certain number of queries can be performed in parallel, while queries of a given stage can be chosen depending on the answers to those of previous stages. Algorithms that operate in few stages are usually preferred in practical applications. We study the case with one positive elementcomprehensively. We obtain asymptotically tight bounds on the number of queries of two-stage strategies for arbitrarily many positives. Finally, we extend our results to strategies with any number of stages and positives

Optimal group testing algorithms with interval queries and their application to splice site detection

We consider the following constrained version of the classical Group Testing problem: Given a finite set of items identified with the set of natural numbers from 1 to n, and an unknown distinguished subset P of up to ppositive elements, the goal is to identify the items in P by asking the least number of queries of the type "does the subset Q intersect P?", where Q is a subset of consecutive elements of cardinality at most d. This particular case of the Group Testing problem naturally arises in computational biology in the context ofsearching for splice sites within a gene. In this paper we focus on algorithms that solve the aforesaid problem and for which queries can be arranged in stages: in each stage a certain number of queries can be performed in parallel, while queries of a given stage can be chosen depending on the answers to those of previous stages. Algorithms that operate in few stages are usually preferred in practical applications. We study the case with one positive elementcomprehensively. We obtain asymptotically tight bounds on the number of queries of two-stage strategies for arbitrarily many positives. Finally, we extend our results to strategies with any number of stages and positives